import { _decorator, Vec3 , Node} from 'cc';
import { SkillManager } from './SkillManager';
import { EBuff, EEvent, EGroup, EntityType, ESkill } from '../Config/Enum';
import ObjectPoolManager from '../Core/ObjectPoolManager';
import { Collider2D } from 'cc';
import { PlayerManager } from '../PlayerManager';
import { BattleManager } from '../BattleManager';
import { Core } from '../Core/Core';
import { EnemyManager } from '../EnemyManager';

const { ccclass } = _decorator;

// 如来千叶手
// 符文1 - 回头是岸 将敌人拉入幻境，经历无尽轮回试炼，10%概率俘虏敌人
// 符文2 - 佛光净土 净化所有敌人增益和减益状态
// 符文3 - 真实伤害


@ccclass('ShaolinSkill3')
export class ShaolinSkill3 extends SkillManager {
    isMasterBullet
    runeId = 0
    numOfBullets = 1; // 默认是3个
    level
    buffAp
    buffDuration
    buffTypeList: EBuff[]
    effectChance
    em: EnemyManager
    // 使用私有字段而非布尔标志
    private _hasSplit = false;
    private _contactPosition: Vec3 = new Vec3(0, 0, 0);
    

    init(type: ESkill, pm: PlayerManager) {



        // // 如果是子子弹，直接super.init(type, pm); 直接释放
        // if (!this.isMasterBullet) {
        //     console.log("1111111111111111test3",this.isTrueDamage)
        //     super.init(type, pm);
        //     return;
        // }
        // // 如果是主子弹，就拿numOfBullets，并判断runeId，走逻辑，再释放
        // if (this.isMasterBullet) {
        //     this._hasSplit = false;
        // }

        super.init(type, pm);
        console.log("1111111111111111test4",this.isTrueDamage)




        switch (this.runeId) {
            case 1:
                //                 // 每隔1秒造成1次伤害
                // this.schedule(() => {
                //     this.em.hurt(this.damage); // 假设takeDamage是敌人组件中的方法
                //     console.log("GaibangSkill3 onHitEnemy this.damage:", this.damage);
                // }, 1, 2, 0);
                break;
            case 2:
                break;  
            case 3:
                this.isTrueDamage = true; // 设置为真实伤害
                break;
            default:
                break;
        }


    }

protected onHitEnemy(self, other: Collider2D): void {
    this.em = other.node.getComponent(EnemyManager)



    switch (this.runeId) {
        case 1:
            //将敌人拉入幻境经历无尽轮回，3%概率俘虏敌人

            if (Math.random() < 0.5) { // 50%概率
                // 俘虏敌人逻辑
                console.log("ShaolinSkill3: 俘虏敌人成功, BattleManager.Instance.prisoner:",BattleManager.Instance.prisoner);
                //ObjectPoolManager.Instance.ret(other.node); // 回收原始子弹
                //Core.Instance.event.emit(EEvent.EnemyDie, other.node.getComponent(EnemyManager));
                //BattleManager.Instance.numOfDeadEnemies++
                BattleManager.Instance.prisoner += 1; // 假设BattleManager有prisoner属性
                
            }

            break;
        case 2:
            // 符文2 - 佛光净土 净化所有敌人增益和减益状态
            
            this.em.buffManager.clearAllBuffs()
            break;  
        case 3:
            // 造成真实伤害

            console.log("1111111111111111test1this.isTrueDamage",this.isTrueDamage)
            //this.em.hurt(this.damage * 0.5); // 假设hurt是敌人组件中的方法

            break;
        default:
            console.log("GaibangSkill1 no rune", this.runeId);
            break;
    }
    
        // 调用父类方法处理伤害
        super.onHitEnemy(self, other);



}

castTwice(){
    // 释放三次随机位置
    //this.createBullet(this._contactPosition);
    this.createBullet(this._contactPosition.add3f(0, 50, 0));
    this.createBullet(this._contactPosition.add3f(50, 0, 0));


    // 原始子弹完成任务，立即回收
    ObjectPoolManager.Instance.ret(this.node);



}

    private createBullet(pos: Vec3) {
        const bulletNode = ObjectPoolManager.Instance.get(this.type as EntityType);
        bulletNode.setWorldPosition(pos);
        //bulletNode.setWorldPosition(200,399,0);
        const bullet = bulletNode.getComponent(ShaolinSkill3);
        if (!bullet) {
            return;
        }

        // 标记为子子弹（非主子弹）
        bullet.isMasterBullet = false;
        // 标记为已分裂（防止子子弹再次分裂）
        bullet._hasSplit = true;


        // 继承原始属性
        bullet.init(this.type, this.pm);


    }



    private initSplitBullet(bulletNode: Node, angle: number): void {
        // 确保节点有基础SkillManager组件
        let sm = bulletNode.getComponent(ShaolinSkill3);

        sm.init(this.type, this.pm);
        sm._hasSplit =  true; // 重置分裂状态
        
        // 计算新方向
        const newDirection = this.calculateSplitDirection(angle);
        sm.setDirection(newDirection);
        
        // 设置分裂后的子弹属性
        sm.damage = this.skill.damage * 0.5;
    }

    // 计算分裂方向
    private calculateSplitDirection(baseAngle: number): Vec3 {
        // 1. 获取当前子弹的角度
        const currentAngle = this.getAngleFromDirection(this.direction);
        
        // 2. 计算新角度（当前角度 + 偏移角度）
        const newAngle = currentAngle + baseAngle;
        
        // 3. 将角度转换为弧度
        const angleRad = newAngle * Math.PI / 180;
        
        // 4. 计算新方向向量
        return new Vec3(
            Math.sin(angleRad),
            Math.cos(angleRad),
            0
        ).normalize();
    }
    
    // 从方向向量获取角度（0-360度）
    private getAngleFromDirection(dir: Vec3): number {
        // 计算从垂直向上(0,1)到目标方向的角度
        const angle = Math.atan2(dir.x, dir.y) * 180 / Math.PI;
        return angle < 0 ? angle + 360 : angle;
    }
}